const apiConfig = require('../../utils/api.js').default

Page({

    /**
     * 页面的初始数据
     */
    data: {
        currentTab: -1, // 当前选中的tab索引，-1表示未选择
        showModule: false, // 是否显示模块
        currentIndex1:0, //当前展示的页（0为封面）
        currentIndex2:0, //盐文化当前展示的页
        currentIndex3:0, //酒文化当前展示的页
        bookBoxTransformStyle1:'',
        bookBoxTransformStyle2:'',
        bookBoxTransformStyle3:'',
        tabs: [
            { id: 0, name: '老照片', top: '550rpx', left: '500rpx', right: 'auto', bottom: 'auto' },
            { id: 1, name: '盐文化', top: '930rpx', left: 'auto', right: '130rpx', bottom: 'auto' },
            { id: 2, name: '酒文化', top: '180rpx', left: 'auto', right: 'auto', bottom: 'auto' }
        ],
        iconBaseUrl:'',
        //书籍数据 - 初始为空，点击按钮时从后端获取
        dataArray1:[],
        //盐文化数据
        dataArray2:[],
        //酒文化数据
        dataArray3:[],
        // 图片加载状态
        imageLoadCount: 0, // 已加载的图片数量
        totalImageCount: 0 // 总图片数量
    },
    onLoad() {
        const iconBaseUrl=apiConfig.ENV.iconBaseUrl;
        const backendUrl=apiConfig.ENV.backendUrl;
        console.log(iconBaseUrl,apiConfig.ENV.backendUrl)
        this.setData({
            iconBaseUrl,
            backendUrl
        })
    },
    /**
     * 打开模块
     */
    openModule(e) {
        const index = parseInt(e.currentTarget.dataset.index);
        console.log('打开模块，index:', index);
        this.setData({
            currentTab: index,
            showModule: true,
        });

        // 点击老照片时，如果数据为空则请求数据
        if (index === 0 && this.data.dataArray1.length === 0) {
            wx.showLoading({
                title: '加载中...',
                mask: true
            });
            this.fetchOldPhotosData();
        }
        // 切换到盐文化或酒文化时，如果数据为空则请求数据
        else if (index === 1 && this.data.dataArray2.length === 0) {
            wx.showLoading({
                title: '加载中...',
                mask: true
            });
            this.fetchSaltCultureData();
        } else if (index === 2 && this.data.dataArray3.length === 0) {
            wx.showLoading({
                title: '加载中...',
                mask: true
            });
            this.fetchWineCultureData();
        }
    },

    /**
     * 关闭模块
     */
    closeModule() {
        // 重置所有模块的当前页下标为0
        this.setData({
            showModule: false,
            currentTab: -1,
            currentIndex1: 0,
            currentIndex2: 0,
            currentIndex3: 0,
            bookBoxTransformStyle1: '',
            bookBoxTransformStyle2: '',
            bookBoxTransformStyle3: ''
        });

        // 重置所有页面的样式到初始状态
        if (this.data.dataArray1.length > 0) {
            let dataArray1 = this.data.dataArray1.map((item, index) => {
                return this.applyTransformByData(item, index, 0, this.data.dataArray1)
            });
            this.setData({ dataArray1 });
        }

        if (this.data.dataArray2.length > 0) {
            let dataArray2 = this.data.dataArray2.map((item, index) => {
                return this.applyTransformByData(item, index, 0, this.data.dataArray2)
            });
            this.setData({ dataArray2 });
        }

        if (this.data.dataArray3.length > 0) {
            let dataArray3 = this.data.dataArray3.map((item, index) => {
                return this.applyTransformByData(item, index, 0, this.data.dataArray3)
            });
            this.setData({ dataArray3 });
        }
    },

    /**
     * 阻止事件冒泡
     */
    stopPropagation() {
        // 阻止事件冒泡，防止点击模块内容时关闭模块
    },

    /**
     * 图片加载完成事件
     */
    onImageLoad(e) {
        const index = e.currentTarget.dataset.index;
        const currentTab = this.data.currentTab;

        // 更新对应数组的封面加载状态
        if (currentTab === 0) {
            // 老照片
            const dataArray1 = [...this.data.dataArray1];
            if (dataArray1[index]) {
                dataArray1[index].imageLoaded = true;
                this.setData({ dataArray1 });
            }
        } else if (currentTab === 1) {
            // 盐文化
            const dataArray2 = [...this.data.dataArray2];
            if (dataArray2[index] && dataArray2[index].time === '封面') {
                dataArray2[index].imageLoaded = true;
                this.setData({ dataArray2 });
            }
        } else if (currentTab === 2) {
            // 酒文化
            const dataArray3 = [...this.data.dataArray3];
            if (dataArray3[index] && dataArray3[index].time === '封面') {
                dataArray3[index].imageLoaded = true;
                this.setData({ dataArray3 });
            }
        }

        const newCount = this.data.imageLoadCount + 1;
        this.setData({
            imageLoadCount: newCount
        });

        // 如果所有图片都加载完成，隐藏loading
        if (newCount >= this.data.totalImageCount && this.data.totalImageCount > 0) {
            wx.hideLoading();
        }
    },

    /**
     * 图片加载失败事件
     */
    onImageError(e) {
        const index = e.currentTarget.dataset.index;
        const currentTab = this.data.currentTab;

        // 更新对应数组的封面加载状态（即使失败也标记为已加载，避免一直显示加载动画）
        if (currentTab === 0) {
            // 老照片
            const dataArray1 = [...this.data.dataArray1];
            if (dataArray1[index]) {
                dataArray1[index].imageLoaded = true;
                this.setData({ dataArray1 });
            }
        } else if (currentTab === 1) {
            // 盐文化
            const dataArray2 = [...this.data.dataArray2];
            if (dataArray2[index] && dataArray2[index].time === '封面') {
                dataArray2[index].imageLoaded = true;
                this.setData({ dataArray2 });
            }
        } else if (currentTab === 2) {
            // 酒文化
            const dataArray3 = [...this.data.dataArray3];
            if (dataArray3[index] && dataArray3[index].time === '封面') {
                dataArray3[index].imageLoaded = true;
                this.setData({ dataArray3 });
            }
        }

        const newCount = this.data.imageLoadCount + 1;
        this.setData({
            imageLoadCount: newCount
        });

        // 即使加载失败，也计入加载完成，避免一直等待
        if (newCount >= this.data.totalImageCount && this.data.totalImageCount > 0) {
            wx.hideLoading();
        }
    },

    //上一页
    beforeData(){
        if (this.data.currentIndex1 == 0) return
        // 如果打开的是第一页则将整本书缩小为原来尺寸
        if(this.data.currentIndex1==1){
            this.setData({
                bookBoxTransformStyle1:'transform:scale(1);perspective:900px'
            })
        }
        const newIndex = this.data.currentIndex1 - 1
        this.setData({
            currentIndex1: newIndex
        })

        console.log('当前为', this.data.currentIndex1)

        // 重新计算所有页面的样式
        const newArray = this.data.dataArray1.map((item, index) => {
            return this.applyTransformByData(item, index, newIndex, this.data.dataArray1)
        })

        this.setData({
            dataArray1: newArray
        })
    },
    //下一页
    nextData(){
        if (this.data.currentIndex1 == this.data.dataArray1.length - 1) return
        // 如果打开的是第一页则将整本书放大
        if(this.data.currentIndex1==0){
            this.setData({
                bookBoxTransformStyle1:'transform:scale(1.4);perspective:1200px'
            })
        }

        const newIndex = this.data.currentIndex1 + 1
        this.setData({
            currentIndex1: newIndex
        })

        console.log('当前为', this.data.currentIndex1)

        // 重新计算所有页面的样式
        const newArray = this.data.dataArray1.map((item, index) => {
            return this.applyTransformByData(item, index, newIndex, this.data.dataArray1)
        })

        this.setData({
            dataArray1: newArray
        })
    },

    /**
     * 预览图片
     */
    previewImage(e) {
        const index = e.currentTarget.dataset.index;
        if (index === undefined || index === null) {
            console.error('预览图片失败：无法获取图片索引');
            return;
        }

        const currentTab = this.data.currentTab;
        let dataArray = [];
        let imageList = [];
        let currentUrl = '';

        if (currentTab === 0) {
            // 老照片模块
            dataArray = this.data.dataArray1;
            // 计算当前图片在视觉上的位置（数组越往后的反而是视觉上书本的前页）
            const visualIndex = dataArray.length - 1 - index;

            // 按照视觉顺序重新排列预览列表（视觉上的第一页应该是预览列表的第一位）
            // 即从数组最后一个元素开始，倒序排列
            for (let i = dataArray.length - 1; i >= 0; i--) {
                if (dataArray[i].imgUrl) {
                    imageList.push(dataArray[i].imgUrl);
                }
            }

            // 当前图片在预览列表中的位置就是它在视觉上的位置
            currentUrl = imageList[visualIndex];
        } else if (currentTab === 1) {
            // 盐文化模块 - 只有封面是图片
            dataArray = this.data.dataArray2;
            const coverItem = dataArray.find(item => item.time === '封面');
            if (coverItem && coverItem.imgUrl) {
                imageList = [coverItem.imgUrl];
                currentUrl = coverItem.imgUrl;
            }
        } else if (currentTab === 2) {
            // 酒文化模块 - 只有封面是图片
            dataArray = this.data.dataArray3;
            const coverItem = dataArray.find(item => item.time === '封面');
            if (coverItem && coverItem.imgUrl) {
                imageList = [coverItem.imgUrl];
                currentUrl = coverItem.imgUrl;
            }
        }

        if (imageList.length === 0) {
            console.error('预览图片失败：没有找到图片');
            return;
        }

        wx.previewImage({
            current: currentUrl, // 当前显示图片的http链接
            urls: imageList // 需要预览的图片http链接列表（按视觉顺序排列）
        });
    },

    //自动生成旋转角度函数
    addDegProperties(objects) {
        if (!Array.isArray(objects) || objects.length === 0) {
            return [];
        }

        return objects.map((obj, index) => {
            // 复制原对象，避免修改原对象
            const newObj = { ...obj };

            // 计算从最后一个元素开始的deg值
            const reverseIndex = objects.length - 1 - index;
            const degValue = -20 + 1.5 * reverseIndex;

            // 如果计算值大于0，则设为0
            newObj.deg = degValue <= 0 ? `${degValue}` : '0';

            return newObj;
        });
    },

    // 通过数据驱动设置样式
    applyTransformByData(item,index,currentIndex,dataArray) {
        const newItem = { ...item }

        // 计算在视觉上的位置（从后往前）
        const visualIndex = dataArray.length - 1 - index

        if (visualIndex < currentIndex) {
            // 已经翻过的页面（在视觉上位于当前页之前）
            newItem.transformStyle = `transform: rotateY(${-180 + visualIndex}deg);`
        } else {
            // 未翻的页面（在视觉上位于当前页之后）
            newItem.transformStyle = `transform: rotateY(${item.deg}deg);`
        }

        return newItem
    },

    // 文本分页函数 - 将长文本切割成多页
    splitTextIntoPages(text, charsPerPage = 400) {
        if (!text || typeof text !== 'string') {
            return [];
        }

        const pages = [];
        let currentPage = '';
        let charCount = 0;

        // 按段落分割
        const paragraphs = text.split(/\n+/);

        for (let i = 0; i < paragraphs.length; i++) {
            const para = paragraphs[i].trim();
            if (!para) continue;

            // 如果当前段落加上当前页超过限制，先保存当前页
            if (charCount + para.length > charsPerPage && currentPage) {
                pages.push(currentPage);
                currentPage = para;
                charCount = para.length;
            } else {
                // 如果单个段落就超过限制，需要进一步切割
                if (para.length > charsPerPage) {
                    if (currentPage) {
                        pages.push(currentPage);
                        currentPage = '';
                        charCount = 0;
                    }
                    // 按字符数切割长段落
                    for (let j = 0; j < para.length; j += charsPerPage) {
                        pages.push(para.substring(j, j + charsPerPage));
                    }
                } else {
                    currentPage += (currentPage ? '\n' : '') + para;
                    charCount += para.length;
                }
            }
        }

        // 添加最后一页
        if (currentPage) {
            pages.push(currentPage);
        }

        return pages;
    },

    // 将文本页转换为数据数组（注意：数组越往后的反而是视觉上书本的前页）
    convertTextToDataArray(textPages) {
        return textPages.map((text, index) => ({
            id: index,
            text: text,
            deg: '' // 会在addDegProperties中设置
        }));
    },

    // 处理文化数据（优化版本，识别标题、类别等）
    processCultureData(cultureItems, dataArrayKey) {
        if (!cultureItems || cultureItems.length === 0) return;

        // 处理每个文化条目，识别标题、类别、正文等
        const processedPages = [];

        cultureItems.forEach((item, itemIndex) => {
            const name = (item.name || '').trim();
            const category = (item.category || '').trim();
            const details = (item.details || '').trim();

            if (!details) return;

            // 构建结构化文本块
            const textBlocks = [];

            // 标题（如果有）
            if (name) {
                textBlocks.push({ type: 'title', content: name });
            }

            // 类别（如果有）
            if (category) {
                textBlocks.push({ type: 'category', content: category });
            }

            // 正文内容，处理段落 - 优化多行空行处理
            // 先合并连续的空行，然后分割段落
            const normalizedDetails = details.replace(/\n{3,}/g, '\n\n'); // 将3个或更多连续换行合并为2个
            const paragraphs = normalizedDetails.split(/\n+/);
            
            // 过滤并处理段落
            const validParagraphs = [];
            paragraphs.forEach((para, paraIndex) => {
                const trimmedPara = para.trim();
                if (trimmedPara) {
                    validParagraphs.push({ content: trimmedPara, originalIndex: paraIndex });
                }
            });

            validParagraphs.forEach((paraObj, paraIndex) => {
                const trimmedPara = paraObj.content;
                
                // 判断是否是署名（通常在最后，且较短，可能包含"——"、"作者"等）
                const isSignature = paraIndex === validParagraphs.length - 1 &&
                    (trimmedPara.length < 50 ||
                        trimmedPara.includes('——') ||
                        trimmedPara.includes('作者') ||
                        trimmedPara.includes('来源'));

                if (isSignature) {
                    textBlocks.push({ type: 'signature', content: trimmedPara });
                } else {
                    // 普通段落，前空两格
                    textBlocks.push({ type: 'paragraph', content: trimmedPara });
                }
            });

            // 将文本块分页（优化分页逻辑，确保标题类别与正文第一段尽量在同一页）
            const pages = this.splitTextBlocksIntoPages(textBlocks);
            processedPages.push(...pages);
        });

        // 注意：数组越往后的反而是视觉上书本的前页，所以需要反转数组
        const reversedPages = processedPages.reverse();
        let dataArray = reversedPages.map((page, index) => ({
            id: index,
            textBlocks: page,
            deg: '',
            isStructured: true,
            richTextNodes: this.convertTextBlocksToRichText(page) // 转换为富文本节点
        }));

        // 在数据最后添加封面（视觉上是最前面）
        let coverUrl = '';
        if (dataArrayKey === 'dataArray2') {
            // 盐文化封面
            coverUrl = 'https://652js.suse.edu.cn/images/BookYanCulture.png';
        } else if (dataArrayKey === 'dataArray3') {
            // 酒文化封面
            coverUrl = 'https://652js.suse.edu.cn/images/BookJiuCulture.png';
        }

        let hasCover = false;
        if (coverUrl) {
            // 添加封面数据，格式类似老照片的封面
            const coverItem = {
                id: dataArray.length,
                imgUrl: coverUrl,
                time: '封面',
                deg: '',
                isCover: true,
                imageLoaded: false // 添加加载状态
            };
            dataArray.push(coverItem);
            hasCover = true;
        }

        dataArray = this.addDegProperties(dataArray);
        dataArray = dataArray.map((item, index) => {
            return this.applyTransformByData(item, index, 0, dataArray)
        });

        const updateData = {};
        updateData[dataArrayKey] = dataArray;

        // 如果有封面，设置图片加载计数（只有封面是图片）
        if (hasCover) {
            updateData.totalImageCount = 1;
            updateData.imageLoadCount = 0;
        }

        this.setData(updateData);
    },

    // 将文本块分页
    splitTextBlocksIntoPages(textBlocks, charsPerPage = 400) {
        if (!textBlocks || textBlocks.length === 0) {
            return [];
        }

        const pages = [];
        let currentPage = [];
        let charCount = 0;

        // 检查当前页是否只包含标题和类别（没有正文段落）
        const hasOnlyHeader = () => {
            return currentPage.length > 0 && 
                   currentPage.every(block => block.type === 'title' || block.type === 'category');
        };

        // 检查是否是第一个正文段落
        const isFirstParagraph = (block) => {
            return block.type === 'paragraph' && 
                   !currentPage.some(b => b.type === 'paragraph');
        };

        textBlocks.forEach((block, blockIndex) => {
            const blockLength = block.content.length;

            // 如果单个块就超过限制，需要特殊处理
            if (blockLength > charsPerPage) {
                // 特殊处理：如果当前页只有标题和类别，且这是第一个正文段落
                // 应该先尝试将段落的一部分放入当前页，而不是直接保存当前页
                if (hasOnlyHeader() && isFirstParagraph(block)) {
                    // 计算当前页还能容纳多少字符
                    const availableSpace = charsPerPage - charCount;
                    
                    // 如果当前页还有空间，先放入一部分内容
                    if (availableSpace > 0) {
                        const chunk = block.content.substring(0, availableSpace);
                        currentPage.push({ type: block.type, content: chunk });
                        pages.push([...currentPage]);
                        currentPage = [];
                        charCount = 0;
                        
                        // 处理剩余内容
                        let remainingContent = block.content.substring(availableSpace);
                        while (remainingContent.length > 0) {
                            if (remainingContent.length <= charsPerPage) {
                                currentPage.push({ type: block.type, content: remainingContent });
                                charCount = remainingContent.length;
                                break;
                            } else {
                                const chunk = remainingContent.substring(0, charsPerPage);
                                pages.push([{ type: block.type, content: chunk }]);
                                remainingContent = remainingContent.substring(charsPerPage);
                            }
                        }
                    } else {
                        // 当前页已满（标题和类别已经占满），需要新建一页
                        pages.push([...currentPage]);
                        currentPage = [];
                        charCount = 0;
                        
                        // 处理长段落
                        let remainingContent = block.content;
                        while (remainingContent.length > 0) {
                            if (remainingContent.length <= charsPerPage) {
                                currentPage.push({ type: block.type, content: remainingContent });
                                charCount = remainingContent.length;
                                break;
                            } else {
                                const chunk = remainingContent.substring(0, charsPerPage);
                                pages.push([{ type: block.type, content: chunk }]);
                                remainingContent = remainingContent.substring(charsPerPage);
                            }
                        }
                    }
                } else {
                    // 如果当前页已经有其他内容（不是只有标题和类别），先保存当前页
                    if (currentPage.length > 0) {
                        pages.push([...currentPage]);
                        currentPage = [];
                        charCount = 0;
                    }
                    
                    // 按字符数切割长块并在多个页面中分布
                    let remainingContent = block.content;
                    while (remainingContent.length > 0) {
                        // 计算当前页面还能容纳多少字符
                        const availableSpace = charsPerPage - charCount;
                        
                        if (availableSpace >= remainingContent.length) {
                            // 如果剩余内容能完全放入当前页
                            currentPage.push({ type: block.type, content: remainingContent });
                            charCount += remainingContent.length;
                            break;
                        } else if (availableSpace > 0) {
                            // 如果当前页还能容纳部分内容，先填满当前页
                            const chunk = remainingContent.substring(0, availableSpace);
                            currentPage.push({ type: block.type, content: chunk });
                            pages.push([...currentPage]);
                            currentPage = [];
                            charCount = 0;
                            remainingContent = remainingContent.substring(availableSpace);
                        } else {
                            // 当前页已满，新建一页
                            if (currentPage.length > 0) {
                                pages.push([...currentPage]);
                            }
                            currentPage = [];
                            charCount = 0;
                            
                            // 如果剩余内容超过一页的容量，分割处理
                            if (remainingContent.length > charsPerPage) {
                                const chunk = remainingContent.substring(0, charsPerPage);
                                pages.push([{ type: block.type, content: chunk }]);
                                remainingContent = remainingContent.substring(charsPerPage);
                            } else {
                                currentPage.push({ type: block.type, content: remainingContent });
                                charCount = remainingContent.length;
                                break;
                            }
                        }
                    }
                }
            } else {
                // 正常大小的块处理
                const wouldExceed = charCount + blockLength > charsPerPage;
                
                // 特殊处理：如果当前页只有标题和类别，且这是第一个正文段落
                // 即使稍微超过限制，也尽量放在同一页（允许超出20%）
                if (wouldExceed && hasOnlyHeader() && isFirstParagraph(block)) {
                    const overflowRatio = (charCount + blockLength) / charsPerPage;
                    // 如果超出不超过20%，仍然放在同一页
                    if (overflowRatio <= 1.2) {
                        currentPage.push(block);
                        charCount += blockLength;
                    } else {
                        // 超出太多，需要分页
                        pages.push([...currentPage]);
                        currentPage = [block];
                        charCount = blockLength;
                    }
                } else if (wouldExceed && currentPage.length > 0) {
                    // 普通情况：超过限制且当前页有内容，先保存当前页
                    pages.push([...currentPage]);
                    currentPage = [block];
                    charCount = blockLength;
                } else {
                    // 可以放入当前页
                    currentPage.push(block);
                    charCount += blockLength;
                }
            }
        });

        // 添加最后一页
        if (currentPage.length > 0) {
            pages.push(currentPage);
        }

        return pages;
    },

    // 将文本块转换为富文本节点
    convertTextBlocksToRichText(textBlocks) {
        if (!textBlocks || textBlocks.length === 0) {
            return '';
        }

        let html = '';

        textBlocks.forEach((block) => {
            const content = this.escapeHtml(block.content);

            switch (block.type) {
                case 'title':
                    html += `<div class="text-title">${content}</div>`;
                    break;
                case 'category':
                    html += `<div class="text-category">${content}</div>`;
                    break;
                case 'paragraph':
                    html += `<div class="text-paragraph">    ${content}</div>`;
                    break;
                case 'signature':
                    html += `<div class="text-signature">${content}</div>`;
                    break;
                default:
                    html += `<div>${content}</div>`;
            }
        });

        return html;
    },

    // HTML转义
    escapeHtml(text) {
        if (!text) return '';
        return text
            .replace(/&/g, '&amp;')
            .replace(/</g, '&lt;')
            .replace(/>/g, '&gt;')
            .replace(/"/g, '&quot;')
            .replace(/'/g, '&#039;');
    },


    // 处理文本数据并更新页面（保留旧方法以兼容）
    processTextData(text, dataArrayKey) {
        if (!text) return;

        const textPages = this.splitTextIntoPages(text);
        // 注意：数组越往后的反而是视觉上书本的前页，所以需要反转数组
        const reversedPages = textPages.reverse();
        let dataArray = this.convertTextToDataArray(reversedPages);

        // 在数据最后添加封面（视觉上是最前面）
        let coverUrl = '';
        if (dataArrayKey === 'dataArray2') {
            // 盐文化封面
            coverUrl = 'https://652js.suse.edu.cn/images/BookYanCulture.png';
        } else if (dataArrayKey === 'dataArray3') {
            // 酒文化封面
            coverUrl = 'https://652js.suse.edu.cn/images/BookJiuCulture.png';
        }

        let hasCover = false;
        if (coverUrl) {
            // 添加封面数据，格式类似老照片的封面
            const coverItem = {
                id: dataArray.length,
                imgUrl: coverUrl,
                time: '封面',
                deg: '',
                isCover: true,
                imageLoaded: false // 添加加载状态
            };
            dataArray.push(coverItem);
            hasCover = true;
        }

        dataArray = this.addDegProperties(dataArray);
        dataArray = dataArray.map((item, index) => {
            return this.applyTransformByData(item, index, 0, dataArray)
        });

        const updateData = {};
        updateData[dataArrayKey] = dataArray;

        // 如果有封面，设置图片加载计数（只有封面是图片）
        if (hasCover) {
            updateData.totalImageCount = 1;
            updateData.imageLoadCount = 0;
        }

        this.setData(updateData);
    },

    // 获取盐文化测试数据
    getSaltCultureTestData() {
        return `盐文化，作为中国传统文化的重要组成部分，源远流长，历史悠久。自古以来，盐不仅是人们日常生活中不可或缺的调味品，更是承载着深厚文化内涵的重要载体。

自贡，这座因盐而兴的城市，拥有两千多年的井盐生产历史。自贡的盐业文化可以追溯到东汉时期，当时这里就已经开始凿井取盐。经过历代的发展，自贡逐渐形成了独特的盐业生产体系和文化传统。

自贡盐业的发展历程中，最著名的当属燊海井。燊海井开凿于清道光年间，历时13年才凿成，深度达1001.42米，是世界上第一口超千米深井。这口井的凿成，标志着中国古代钻井技术的巅峰，也体现了自贡人民在盐业生产中的智慧和勇气。

自贡的盐文化不仅体现在生产技术方面，更体现在社会生活的方方面面。盐商文化、盐工文化、盐业建筑文化等，共同构成了自贡独特的盐文化体系。这些文化元素相互交融，形成了自贡独特的城市文化特色。

在自贡，盐文化已经深深融入到人们的生活中。无论是传统的盐业生产技艺，还是与盐相关的民俗活动，都体现了自贡人民对盐文化的传承和发展。这种文化传承不仅是对历史的尊重，更是对未来的展望。

随着时代的发展，自贡的盐文化也在不断创新和发展。在保护传统盐业文化的同时，自贡也在积极探索盐文化的现代价值，将传统文化与现代生活相结合，让盐文化在新的时代背景下焕发出新的生机和活力。

自贡盐文化的发展，不仅丰富了中国的文化宝库，也为世界了解中国传统文化提供了一个重要的窗口。通过盐文化，我们可以更好地理解中国传统文化的精神内涵，感受中华民族的智慧和创造力。`;
    },

    // 获取酒文化测试数据
    getWineCultureTestData() {
        return `酒文化，作为中华文明的重要组成部分，有着数千年的悠久历史。酒不仅是人们生活中的饮品，更是承载着深厚文化内涵的重要载体，在中国传统文化中占据着重要地位。

自贡地区的酒文化同样源远流长。这里不仅有着丰富的酿酒历史，更有着独特的酒文化传统。自贡的酒文化与盐文化相互交融，共同构成了这座城市独特的文化特色。

在自贡，酒文化体现在多个方面。首先是酿酒技艺的传承。自贡地区有着悠久的酿酒历史，传统的酿酒工艺代代相传，形成了独特的酿酒技术。这些技艺不仅体现了劳动人民的智慧，更是中华文明的重要组成部分。

其次是酒文化的社交功能。在自贡，酒是人们社交活动中的重要媒介。无论是节庆活动，还是日常聚会，酒都扮演着重要的角色。通过酒，人们增进感情，交流思想，传承文化。

再次是酒文化的艺术价值。自贡的酒文化不仅体现在酿酒技艺上，更体现在与酒相关的文学、艺术作品中。许多文人墨客以酒为题材，创作了大量优秀的文学作品，丰富了中国的文学宝库。

自贡的酒文化还体现在民俗活动中。在各种传统节日和庆典活动中，酒都是不可或缺的元素。这些民俗活动不仅传承了酒文化，也丰富了人们的精神文化生活。

随着时代的发展，自贡的酒文化也在不断创新。在传承传统酿酒技艺的同时，自贡也在积极探索酒文化的现代价值，将传统文化与现代生活相结合，让酒文化在新的时代背景下焕发出新的生机。

自贡的酒文化发展，不仅丰富了中国的文化宝库，也为世界了解中国传统文化提供了一个重要的窗口。通过酒文化，我们可以更好地理解中国传统文化的精神内涵，感受中华民族的智慧和创造力，体验中华文明的博大精深。`;
    },

    //盐文化上一页
    beforeData2(){
        if (this.data.currentIndex2 == 0) return
        if(this.data.currentIndex2==1){
            this.setData({
                bookBoxTransformStyle2:'transform:scale(1);perspective:900px'
            })
        }
        const newIndex = this.data.currentIndex2 - 1
        this.setData({
            currentIndex2: newIndex
        })

        const newArray = this.data.dataArray2.map((item, index) => {
            return this.applyTransformByData(item, index, newIndex, this.data.dataArray2)
        })

        this.setData({
            dataArray2: newArray
        })
    },

    //盐文化下一页
    nextData2(){
        if (this.data.currentIndex2 == this.data.dataArray2.length - 1) return
        if(this.data.currentIndex2==0){
            this.setData({
                bookBoxTransformStyle2:'transform:scale(1.5);perspective:3000px'
            })
        }

        const newIndex = this.data.currentIndex2 + 1
        this.setData({
            currentIndex2: newIndex
        })

        const newArray = this.data.dataArray2.map((item, index) => {
            return this.applyTransformByData(item, index, newIndex, this.data.dataArray2)
        })

        this.setData({
            dataArray2: newArray
        })
    },

    //酒文化上一页
    beforeData3(){
        if (this.data.currentIndex3 == 0) return
        if(this.data.currentIndex3==1){
            this.setData({
                bookBoxTransformStyle3:'transform:scale(1);perspective:900px'
            })
        }
        const newIndex = this.data.currentIndex3 - 1
        this.setData({
            currentIndex3: newIndex
        })

        const newArray = this.data.dataArray3.map((item, index) => {
            return this.applyTransformByData(item, index, newIndex, this.data.dataArray3)
        })

        this.setData({
            dataArray3: newArray
        })
    },

    //酒文化下一页
    nextData3(){
        if (this.data.currentIndex3 == this.data.dataArray3.length - 1) return
        if(this.data.currentIndex3==0){
            this.setData({
                bookBoxTransformStyle3:'transform:scale(1.5);perspective:3000px'
            })
        }

        const newIndex = this.data.currentIndex3 + 1
        this.setData({
            currentIndex3: newIndex
        })

        const newArray = this.data.dataArray3.map((item, index) => {
            return this.applyTransformByData(item, index, newIndex, this.data.dataArray3)
        })

        this.setData({
            dataArray3: newArray
        })
    },

    // 请求老照片数据
    fetchOldPhotosData() {
        const {backendUrl} = this.data;
        const url = `${backendUrl}api/img/client/user/selected`;

        wx.request({
            url: url,
            method: 'GET',
            success: (res) => {
                console.log('老照片数据请求成功', res);
                if (res.data && res.data.code === 200 && Array.isArray(res.data.data)) {
                    // 保留所有数据，包括封面
                    const photoList = res.data.data.filter(item => item.imgUrl);

                    if (photoList.length === 0) {
                        wx.hideLoading();
                        wx.showToast({
                            title: '暂无数据',
                            icon: 'none'
                        });
                        return;
                    }

                    // 转换为数据格式，不反转数组
                    let dataArray = photoList.map((item, index) => ({
                        id: index,
                        name: item.name || `老照片${index + 1}`,
                        imgUrl: item.imgUrl,
                        time: item.type || '', // 使用type作为分类标识
                        deg: '', // 会在addDegProperties中设置
                        imageLoaded: false // 添加加载状态
                    }));

                    // 添加旋转角度
                    dataArray = this.addDegProperties(dataArray);
                    // 初始化样式
                    dataArray = dataArray.map((item, index) => {
                        return this.applyTransformByData(item, index, 0, dataArray)
                    });

                    // 设置总图片数量并重置加载计数
                    this.setData({
                        dataArray1: dataArray,
                        totalImageCount: dataArray.length,
                        imageLoadCount: 0
                    });

                    // 如果图片数量为0，直接隐藏loading
                    if (dataArray.length === 0) {
                        wx.hideLoading();
                    }
                    // 否则等待所有图片加载完成（通过onImageLoad事件）
                } else {
                    console.warn('老照片数据格式异常', res.data);
                    wx.hideLoading();
                    wx.showToast({
                        title: '数据格式异常',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('请求老照片数据失败', err);
                wx.hideLoading();
                wx.showToast({
                    title: '加载失败',
                    icon: 'none'
                });
            }
        });
    },

    // 请求盐文化数据
    fetchSaltCultureData() {
        const app = getApp();

        const {backendUrl} = this.data;
        const url = `${backendUrl}api/culture/type/盐文化`;

        wx.request({
            url: url,
            method: 'GET',
            success: (res) => {
                console.log('盐文化数据请求成功', res);
                if (res.data && res.data.code === 200 && Array.isArray(res.data.data)) {
                    // 保留原始数据结构以便识别标题、类别等
                    const cultureItems = res.data.data.filter(item => item.details);

                    if (cultureItems.length > 0) {
                        this.processCultureData(cultureItems, 'dataArray2');
                        wx.hideLoading();
                    } else {
                        wx.hideLoading();
                        wx.showToast({
                            title: '暂无数据',
                            icon: 'none'
                        });
                    }
                } else {
                    console.warn('盐文化数据格式异常', res.data);
                    wx.hideLoading();
                    wx.showToast({
                        title: '数据格式异常',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('请求盐文化数据失败', err);
                wx.hideLoading();
                wx.showToast({
                    title: '加载失败',
                    icon: 'none'
                });
            }
        });
    },

    // 请求酒文化数据
    fetchWineCultureData() {
        const app = getApp();
        const {backendUrl} = this.data;
        const url = `${backendUrl}api/culture/type/酒文化`;

        wx.request({
            url: url,
            method: 'GET',
            success: (res) => {
                console.log('酒文化数据请求成功', res);
                if (res.data && res.data.code === 200 && Array.isArray(res.data.data)) {
                    // 保留原始数据结构以便识别标题、类别等
                    const cultureItems = res.data.data.filter(item => item.details);

                    if (cultureItems.length > 0) {
                        this.processCultureData(cultureItems, 'dataArray3');
                        wx.hideLoading();
                    } else {
                        wx.hideLoading();
                        wx.showToast({
                            title: '暂无数据',
                            icon: 'none'
                        });
                    }
                } else {
                    console.warn('酒文化数据格式异常', res.data);
                    wx.hideLoading();
                    wx.showToast({
                        title: '数据格式异常',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('请求酒文化数据失败', err);
                wx.hideLoading();
                wx.showToast({
                    title: '加载失败',
                    icon: 'none'
                });
            }
        });
    },

    /**
     * 生命周期函数--监听页面加载
     */

    onReady() {

    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {

    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {

    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {

    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {

    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {

    }
})